perm filename PIXSAI.SAI[S,HE] blob
sn#658975 filedate 1982-05-09 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00018 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00004 00002 entry pixdim,pfldim,OPNPFL,CREPFL,getpfl,getpfd,putpfl,campix,CLPADJ,makpix,MAKDIM
C00008 00003 incremental file reading and writing routine pointers
C00009 00004 INTERNAL INTEGER PROCEDURE OPNPFL(STRING PFL REFERENCE INTEGER PC)
C00014 00005 INTERNAL INTEGER PROCEDURE CREPFL(REFERENCE INTEGER PICTURE STRING FILNAM
C00017 00006 INTERNAL PROCEDURE PFLIN(INTEGER CH REFERENCE INTEGER AR INTEGER NWDS)
C00018 00007 INTERNAL PROCEDURE PFLOUT(INTEGER CH REFERENCE INTEGER AR INTEGER NWDS)
C00020 00008 INTERNAL PROCEDURE PFLCLS(INTEGER CH)
C00021 00009 INTERNAL INTEGER PROCEDURE PFLDIM(STRING FILNAM)
C00024 00010 INTERNAL INTEGER PROCEDURE GETPFP(STRING FILNAM REFERENCE INTEGER PICTURE
C00031 00011 internal INTEGER PROCEDURE GETPFD(STRING FILNAM REFERENCE INTEGER PICTURE)
C00035 00012 internal INTEGER PROCEDURE GETPFL(STRING FILNAM REFERENCE INTEGER PICTURE)
C00041 00013 internal INTEGER PROCEDURE PIXDIM(INTEGER HEIGHT,WIDTH,BITS)
C00045 00014 internal INTEGER PROCEDURE PUTPFL(REFERENCE INTEGER PICTURE STRING FILNAM
C00050 00015 internal INTEGER PROCEDURE diminterest(REFERENCE INTEGER PICTURE INTEGER IW)
C00052 00016 INTERNAL PROCEDURE ENHANCE(REFERENCE INTEGER PIC)
C00053 00017 INTERNAL PROCEDURE SYNCHRONIZE(REFERENCE INTEGER PIC)
C00055 00018 All gone now...just like the digitizer
C00064 ENDMK
C⊗;
entry pixdim,pfldim,OPNPFL,CREPFL,getpfl,getpfd,putpfl,campix,CLPADJ,makpix,MAKDIM;
entry normalize, synchronize,diminterest,interest,PFLIN,PFLOUT,PFLCLS;
begin
REQUIRE "FILHDR.SAI[VIS,HPM]" SOURCE_FILE;
DEFINE PCLN=0; comment index of word in a picture file containing
number of scanlines in the picture;
DEFINE PCWD=1; comment number of words in the picture;
DEFINE PCBY=2; comment number of valid bytes in the picture;
DEFINE PCBYA=3; comment no. of bytes including the nulls at the end of lines;
DEFINE LNWD=4; comment no. of words per scanline;
DEFINE LNBY=5; comment no. of valid bytes per scanline;
DEFINE LNBYA=6; comment no. of bytes per scanline, including the nulls;
DEFINE WDBY=7; comment no. of bytes per word;
DEFINE WDBI=8; comment no. of bits containing data in a word;
DEFINE BYBI=9; comment no. of bits per byte;
DEFINE BMAX=10; comment largest value of a byte;
DEFINE BPTAB=11; comment address of second entry in byte pntr. table;
DEFINE LINTAB=12; comment actual address of the first entry in the row table;
EXTERNAL PROCEDURE MAKTAB(REFERENCE INTEGER PICTURE);
EXTERNAL INTEGER PROCEDURE INTOP(REFERENCE INTEGER PICTURE;
INTEGER WINSIZ;
REFERENCE INTEGER RESULTARRY;
INTEGER YEDGE(0),XEDGE(0));
EXTERNAL PROCEDURE GETPAR(REFERENCE INTEGER ARRY, PICTR);
EXTERNAL PROCEDURE PERBIT(REFERENCE INTEGER PICTURE, PERMUTATION);
EXTERNAL PROCEDURE HISTOG(REFERENCE INTEGER PICTURE, HISTOGRAM);
EXTERNAL PROCEDURE ROWSUM(REFERENCE INTEGER PICTURE, RWSUM);
EXTERNAL PROCEDURE ROWSUD(REFERENCE INTEGER PICTURE, RWSUM);
EXTERNAL INTEGER PROCEDURE CMPPAR(REFERENCE INTEGER PIC1,PIC2);
EXTERNAL PROCEDURE CLEAN(REFERENCE INTEGER PICTURE);
EXTERNAL PROCEDURE PASSHI(REFERENCE INTEGER PICTURE1;
INTEGER WINSIZ;
REFERENCE INTEGER PICTURE2);
EXTERNAL PROCEDURE HAFPIC(REFERENCE INTEGER PICTURE1,PICTURE2; INTEGER MAXBIT);
EXTERNAL INTEGER PROCEDURE MATCH(REFERENCE INTEGER PIC1,SY1,SX1,SY2,SX2;
REFERENCE INTEGER PIC2,DY1,DX1,DY2,DX2);
EXTERNAL PROCEDURE UNPACK(REFERENCE INTEGER SOURCEARRAY, PICTURE);
EXTERNAL PROCEDURE SELECT(REFERENCE INTEGER PICT1; INTEGER YEDGE,XEDGE;
REFERENCE INTEGER PICT2);
comment incremental file reading and writing routine pointers;
OWN INTEGER ARRAY PTYP,BITW,BITN,PREV,BUFP[0:'17],LBU[0:'17,1:36];
comment position markers for data-compressed files;
INTERNAL INTEGER PROCEDURE OPNPFL(STRING PFL; REFERENCE INTEGER PC);
comment Open a picture file for reading. Next PFLRD will
get beginning of first scanline in picture. PC[0:10] contains
the picture parameters if successful. Function returns channel
number on which file is open;
BEGIN
OWN INTEGER COUNT,BRCHAR,EOF,CH; BOOLEAN FLAG;
INTEGER I,J,K; INTEGER ARRAY BUF[0:20];
CH←GETCHAN; PRSFIL(PFL); EOF←TRUE;
OPEN(CH,DEVPRS,'10,19,0,COUNT,BRCHAR,EOF);
IF ¬EOF THEN LOOKUP(CH,FILPRS,FLAG);
IF FLAG ∨ EOF THEN
BEGIN
RELEASE(CH);
RETURN(-1);
END;
ARRYIN(CH,BUF[0],10);
IF BUF[0]=-1∨BUF[0]=-2∨BUF[0]=128 THEN
BEGIN "new HE (or MIT) format or data compressed format, or CMU format"
ARRYIN(CH,BUF[10],9);
I←'200;
comment in case file is MIT pseudo stanford format, and has no pointers;
IF BUF[0]≠128 THEN FOR K←18,17,16,15,10,9,8,7 DO IF BUF[K]≠0 THEN I←BUF[K];
MEMORY[LOCATION(PC)+BYBI]←BUF[1];
MEMORY[LOCATION(PC)+BMAX]←(1 LSH MEMORY[LOCATION(PC)+BYBI])-1;
MEMORY[LOCATION(PC)+LNBY]←IF BUF[0]=128 THEN BUF[2] ELSE BUF[6]-BUF[5]+1;
MEMORY[LOCATION(PC)+PCLN]←IF BUF[0]=128 THEN BUF[4]%BUF[3] ELSE BUF[4]-BUF[3]+1;
MEMORY[LOCATION(PC)+WDBY]←36%MEMORY[LOCATION(PC)+BYBI];
MEMORY[LOCATION(PC)+LNWD]←IF BUF[0]=128 THEN BUF[3] ELSE BUF[2];
MEMORY[LOCATION(PC)+LNBYA]←MEMORY[LOCATION(PC)+LNWD]*MEMORY[LOCATION(PC)+WDBY];
MEMORY[LOCATION(PC)+PCWD]←MEMORY[LOCATION(PC)+PCLN]*MEMORY[LOCATION(PC)+LNWD];
MEMORY[LOCATION(PC)+PCBY]←MEMORY[LOCATION(PC)+PCLN]*MEMORY[LOCATION(PC)+LNBY];
MEMORY[LOCATION(PC)+PCBYA]←MEMORY[LOCATION(PC)+PCLN]*MEMORY[LOCATION(PC)+LNBYA];
MEMORY[LOCATION(PC)+WDBI]←MEMORY[LOCATION(PC)+WDBY]*MEMORY[LOCATION(PC)+BYBI];
I←(I LAND '777777);
FOR J←I-1 STEP -1 UNTIL 19 DO WORDIN(CH); comment skip to first scanline;
PTYP[CH]←BUF[0]; BITN[CH]←1; PREV[CH]←0;
END
ELSE
BEGIN comment if old hand eye format;
MEMORY[LOCATION(PC)+BYBI]←BUF[2];
MEMORY[LOCATION(PC)+BMAX]←(1 LSH MEMORY[LOCATION(PC)+BYBI])-1;
MEMORY[LOCATION(PC)+LNBY]←BUF[8]-BUF[7]+1;
MEMORY[LOCATION(PC)+PCLN]←BUF[6]-BUF[5]+1;
MEMORY[LOCATION(PC)+WDBY]←36%MEMORY[LOCATION(PC)+BYBI];
MEMORY[LOCATION(PC)+LNWD]←(MEMORY[LOCATION(PC)+LNBY]+MEMORY[LOCATION(PC)+WDBY]-1)%MEMORY[LOCATION(PC)+WDBY];
MEMORY[LOCATION(PC)+LNBYA]←MEMORY[LOCATION(PC)+LNWD]*MEMORY[LOCATION(PC)+WDBY];
MEMORY[LOCATION(PC)+PCWD]←MEMORY[LOCATION(PC)+PCLN]*MEMORY[LOCATION(PC)+LNWD];
MEMORY[LOCATION(PC)+PCBY]←MEMORY[LOCATION(PC)+PCLN]*MEMORY[LOCATION(PC)+LNBY];
MEMORY[LOCATION(PC)+PCBYA]←MEMORY[LOCATION(PC)+PCLN]*MEMORY[LOCATION(PC)+LNBYA];
MEMORY[LOCATION(PC)+WDBI]←MEMORY[LOCATION(PC)+WDBY]*MEMORY[LOCATION(PC)+BYBI];
IF MEMORY[LOCATION(PC)+BYBI]≤0 ∨ MEMORY[LOCATION(PC)+BYBI]>36
∨ MEMORY[LOCATION(PC)+LNBY]≤0 ∨ MEMORY[LOCATION(PC)+PCLN]≤0 ∨ BUF[0]<0 THEN
BEGIN RELEASE(CH); RETURN(-1); END;
PTYP[CH]←-1;
END;
RETURN(CH);
END;
INTERNAL INTEGER PROCEDURE CREPFL(REFERENCE INTEGER PICTURE; STRING FILNAM;
INTEGER MODE(1));
comment write a picture file header on disk and leave file
open for writing. Function returns channel number
on which file is open. Next word written will go into
first data word position in the file. PICTURE must contain
at least the 11 words of header information of the
internal picture representation. If mode is 2, file will
be data compressed;
BEGIN
INTEGER COUNT,BRCHAR,EOF,PICLOC; BOOLEAN FLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L,CH;
INTEGER ARRAY BUF[0:'177];
CH←GETCHAN;
PRSFIL(FILNAM);
EOF←TRUE;
OPEN(CH,DEVPRS,'10,0,19,COUNT,BRCHAR,EOF);
IF ¬EOF THEN ENTER(CH,FILPRS,FLAG);
IF FLAG ∨ EOF THEN
BEGIN
RELEASE(CH);
RETURN(-1);
END
ELSE
BEGIN
L←LOCATION(PICTURE);
BUF[0]←-MODE;
BUF[1]←XBYBI←MEMORY[L+BYBI];
BUF[2]←XLNWD←MEMORY[L+LNWD];
BUF[3]←1; BUF[4]←XPCLN←MEMORY[L+PCLN];
BUF[5]←1; BUF[6]←XLNBY←MEMORY[L+LNBY];
BUF[7]←((-(XPCWD←MEMORY[L+PCWD])) LSH 18) LOR '200;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
ARRYOUT(CH,BUF[0],'200);
PTYP[CH]←MODE; BITN[CH]←'400000000000; PREV[CH]←0; BUFP[CH]←0; BITW[CH]←0;
RETURN(CH);
END;
END;
INTERNAL PROCEDURE PFLIN(INTEGER CH; REFERENCE INTEGER AR; INTEGER NWDS);
comment reads the next NWDS words from the picture file
that has been OPNPFL'd on channel CH;
BEGIN
IF PTYP[CH]=-1∨PTYP[CH]=128 THEN ARRYIN(CH,AR,NWDS) ELSE
IF PTYP[CH]=-2 THEN
BEGIN
INTEGER I;
FOR I←0 STEP 1 UNTIL NWDS-1 DO
BEGIN
IF (BITN[CH]←BITN[CH] LSH -1)=0 THEN
BEGIN BITW[CH]←WORDIN(CH); BITN[CH]←'400000000000; END;
IF (BITW[CH] LAND BITN[CH])≠0 THEN PREV[CH]←WORDIN(CH);
MEMORY[LOCATION(AR)+I]←PREV[CH];
END;
END;
END;
INTERNAL PROCEDURE PFLOUT(INTEGER CH; REFERENCE INTEGER AR; INTEGER NWDS);
comment writes the next NWDS words from the picture file
that has been CREPFL'd on channel CH;
BEGIN
IF PTYP[CH]=1∨PTYP[CH]=128 THEN ARRYOUT(CH,AR,NWDS) ELSE
IF PTYP[CH]=2 THEN
BEGIN
INTEGER I;
FOR I←0 STEP 1 UNTIL NWDS-1 DO
BEGIN
IF MEMORY[LOCATION(AR)+I]≠PREV[CH] THEN
BEGIN
LBU[CH,BUFP[CH]←BUFP[CH]+1]←(PREV[CH]←MEMORY[LOCATION(AR)+I]);
BITW[CH]←BITW[CH] LOR BITN[CH];
END;
IF (BITN[CH]←BITN[CH] LSH -1)=0 THEN
BEGIN
WORDOUT(CH,BITW[CH]); ARRYOUT(CH,LBU[CH,1],BUFP[CH]);
BITN[CH]←'400000000000; BUFP[CH]←0; BITW[CH]←0;
END;
END;
END;
END;
INTERNAL PROCEDURE PFLCLS(INTEGER CH);
BEGIN
IF PTYP[CH]=2 ∧ BITN[CH]≠'400000000000 THEN
BEGIN WORDOUT(CH,BITW[CH]); ARRYOUT(CH,LBU[CH,1],BUFP[CH]); END;
RELEASE(CH);
END;
INTERNAL INTEGER PROCEDURE PFLDIM(STRING FILNAM);
comment returns the size of the picture FILNAM on disk.
used for allocating arrays in preparation for
actually reading them. Returns 0 on failure.;
BEGIN
INTEGER COUNT,BRCHAR,EOF,PICLOC,CH; BOOLEAN FLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER ARRAY BUF[0:'177];
CH←GETCHAN;
PRSFIL(FILNAM);
EOF←TRUE;
OPEN(CH,DEVPRS,'10,19,0,COUNT,BRCHAR,EOF);
IF ¬EOF THEN LOOKUP(CH,FILPRS,FLAG);
IF FLAG ∨ EOF THEN
BEGIN
RELEASE(CH);
RETURN(0);
END
ELSE
BEGIN
ARRYIN(CH,BUF[0],'200); RELEASE(CH);
IF BUF[0]=-1∨BUF[0]=-2∨BUF[0]=128 THEN
BEGIN
XBYBI←BUF[1];
XLNBY←IF BUF[0]=128 THEN BUF[2] ELSE BUF[6]-BUF[5]+1;
XPCLN←IF BUF[0]=128 THEN BUF[4]%BUF[3] ELSE BUF[4]-BUF[3]+1;
XLNWD←IF BUF[0]=128 THEN BUF[3] ELSE BUF[2];
XLNBYA←XLNWD*(36%XBYBI);
XPCWD←XLNWD*XPCLN;
RETURN(13+XPCLN+XLNBYA+XPCWD);
END
ELSE
BEGIN
XBYBI←BUF[2];
XLNBY←BUF[8]-BUF[7]+1;
XPCLN←BUF[6]-BUF[5]+1;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
XPCBY←XPCLN*XLNBY;
XPCBYA←XPCLN*XLNBYA;
XWDBI←XWDBY*XBYBI;
IF XBYBI≤0 ∨ XBYBI>36 ∨ XLNBY≤0 ∨ XPCLN≤0 ∨ BUF[0]<0 THEN RETURN(0)
ELSE RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
END;
END;
INTERNAL INTEGER PROCEDURE GETPFP(STRING FILNAM; REFERENCE INTEGER PICTURE;
INTEGER Y1,X1,COMY,COMX);
comment read and compress a portion of picture in file FILNAM into PICTURE.
upper left corner of area FILNAM transferred is
[y1,x1]. pixel squares of size COMY by COMX are
summed into each pixel of PICTURE
Returns picture size of success, 0 on failure.;
BEGIN
INTEGER COUNT,BRCHAR,EOF,PICLOC,CH; BOOLEAN FLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L,FW,LW,FB,BPT,II,J,K;
INTEGER ARRAY BUF[0:'177];
CH←GETCHAN;
PRSFIL(FILNAM);
EOF←TRUE;
OPEN(CH,DEVPRS,'10,19,0,COUNT,BRCHAR,EOF);
IF ¬EOF THEN LOOKUP(CH,FILPRS,FLAG);
IF FLAG ∨ EOF THEN
BEGIN
RELEASE(CH);
RETURN(0);
END
ELSE
BEGIN
INTEGER K,KK;
ARRYIN(CH,BUF[0],10);
IF BUF[0]=-1∨BUF[0]=128 THEN
BEGIN
ARRYIN(CH,BUF[10],'200-10);
KK←'200;
comment in case file is MIT pseudo stanford format, and has no pointers;
IF BUF[0]≠128 THEN FOR K←18,17,16,15,10,9,8,7 DO IF BUF[K]≠0 THEN KK←BUF[K];
L←LOCATION(PICTURE);
XBYBI←BUF[1];
XLNBY←IF BUF[0]=128 THEN BUF[2] ELSE BUF[6]-BUF[5]+1;
XPCLN←IF BUF[0]=128 THEN BUF[4]%BUF[3] ELSE BUF[4]-BUF[3]+1;
XWDBY←36%XBYBI;
XLNWD←IF BUF[0]=128 THEN BUF[3] ELSE BUF[2];
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
XPCBY←XPCLN*XLNBY;
XPCBYA←XPCLN*XLNBYA;
XWDBI←XWDBY*XBYBI;
PICLOC←(KK LAND '777777);
END
ELSE
BEGIN comment if old hand eye format;
L←LOCATION(PICTURE);
XBYBI←BUF[2];
XLNBY←BUF[8]-BUF[7]+1;
XPCLN←BUF[6]-BUF[5]+1;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
XPCBY←XPCLN*XLNBY;
XPCBYA←XPCLN*XLNBYA;
XWDBI←XWDBY*XBYBI;
IF XBYBI≤0 ∨ XBYBI>36 ∨ XLNBY≤0 ∨ XPCLN≤0 ∨ BUF[0]<0 THEN
BEGIN
RELEASE(CH);
RETURN(0);
END;
PICLOC←10;
END;
FB←X1 MOD XWDBY;
FW←X1 % XWDBY;
LW←(X1+MEMORY[L+LNBY]*COMX-1) % XWDBY;
BEGIN
INTEGER ARRAY BF[0:LW-FW], PIXL[0:MEMORY[L+LNBY]-1];
INTEGER SCAN,SCAD;
PROCEDURE POSN(INTEGER WRD);
BEGIN
INTEGER I; INTEGER ARRAY BU[0:WRD MOD 128];
WRD←WRD+PICLOC;
USETI(CH,WRD%128+1);
ARRYIN(CH,BU[0],WRD MOD 128);
END;
SCAN←MEMORY[L+BMAX]+1; SCAD←(COMX*COMY*2↑XBYBI);
FOR I←0 STEP 1 UNTIL MEMORY[L+PCLN]-1 DO
BEGIN
POSN((I*COMY+Y1)*XLNWD+FW); ARRYIN(CH,BF[0],LW-FW+1);
BPT←POINT(XBYBI,BF[0],FB*XBYBI-1);
FOR K←0 STEP 1 UNTIL MEMORY[L+LNBY]-1 DO
BEGIN
PIXL[K]←ILDB(BPT);
FOR KK←2 STEP 1 UNTIL COMX DO PIXL[K]←PIXL[K]+ILDB(BPT);
END;
FOR II←2 STEP 1 UNTIL COMY DO
BEGIN
INTEGER BPT;
POSN((I*COMY+Y1+II-1)*XLNWD+FW); ARRYIN(CH,BF[0],LW-FW+1);
BPT←POINT(XBYBI,BF[0],FB*XBYBI-1);
FOR K←0 STEP 1 UNTIL MEMORY[L+LNBY]-1 DO
FOR KK←1 STEP 1 UNTIL COMX DO PIXL[K]←PIXL[K]+ILDB(BPT);
END;
FOR J←0 STEP 1 UNTIL MEMORY[L+LNBY]-1 DO
BEGIN
EXTERNAL PROCEDURE PUTEL(REFERENCE INTEGER PIX; INTEGER I,J,VALUE);
PUTEL(MEMORY[L],I,J,(PIXL[J]*SCAN)%SCAD);
END;
END;
END;
END;
END;
internal INTEGER PROCEDURE GETPFD(STRING FILNAM; REFEREJCE INTEGER PICTURE);
comment read the header of file FILNAM into area of core whose firsT
word is PICTURE. Used to Get parameters od a Picture on disk8~∀∩∪IKike9fAaS
ikeJ↓gSuJ↓←\AgUGGKgLX@`A=\AMC%YkeJ8~∀$L#↔∂'n 1↓E
β←?K'→βπK*βK↔S/∪;↔⊃bαB&∞%*J∃βo+OQβ⊗)βπQεc↔πO"βS#'~β '≥Xh)↓↓∧∩⊗≡&ph)↓↓∧J:R⊗<*Iα∞⎇*:Q2∃∩∞"ε∩b⊗>→eα&∞2|→mα
|z2⊗εrα~2ε;X4)↓αα&:R,:⊗IαEα∞29eBB∞↑"bbB∞∃I2bB≤∩f¬2Db:↑⊃eB2:
Jbb2:∃J¬2b<"
e2E:∩
%eB
f
KX4)↓αα&:R,:⊗IαJb12∞CX4)↓αα&:R,:⊗Iα
∩Jεe∧∩V~mβQ≥E]=il4(hQ↓↓α≤B}≡⊗$~"ε9Xh)↓↓¬αJN~La"~&drε5%Xh)↓↓∧*>~}%∩V∃lhQ↓↓α⎇α⊗9"≤A2∩⊗5αJM1; A1EJaA2∞⎇*:Q2∃∩∞"ε∩b⊗>→KX4)↓αα&→,*>→α$B⊗9αdz>.VαB∞!24J2BJ~b~2ε:Il4)α↓α&→∧22ε≥↓yα⊗>2αR"⊗ph)↓↓α↓↓↓α∀*≡&8hQ↓↓↓α↓↓αJ,b⊗εN*B∞!%Xh)↓↓α↓↓↓α∀*RVJrAA%lhQ↓↓↓α↓↓α⊗t 4)↓αα⊗2N(h)↓↓α↓↓α
,:&84R↓↓↓↓ααεJJLJ9"∞Bb
V~[αu1EαIl4)α↓↓↓↓∧J→α
,2mBujiD}
,2mBujiH}
,2mBuk Iaα$B⊗84R↓↓↓↓α↓↓↓α∀*≡&8hQ↓↓↓α↓↓↓↓∧
JJfLq"∞!d∩V~m αu1≥∪↓A5EαIl4)α↓↓↓↓α↓↓α2|b>∞ε$J>9"∧J∞RV∀)%l4R↓↓↓↓α↓↓↓αl*6>JMZ1.
L∩&v}D∩f
&|∩V~m
il4)α↓↓↓↓α↓↓α6,j>Jf\a.2:∃Jv}bdr
f}L1α
V5YBuu ⊃aαRD*9α
,2mJu∧*2N∃∧∩V~m5i6
V5YVu- X4)↓α↓↓↓↓α↓α6⊗lzJfnbZB∞2uj}bB≤b:}&2α
V~[αuuE∪AαR",qα
V5YRu⊗∃*~mNjα⊗2N*α
V~["u6
,2mNu[ l4)α↓↓↓↓α↓↓α6,j>Jf\a.↑∩∃Jv}b<"
f⎇≠1⊗b
L∩%l4R↓↓↓↓α↓↓↓αl*6>JMZ1.2u:∩v}Db:↑∩|J→α
,2mBuk Iaα$B⊗9α∃*~mNjα⊗2N*α
V~[∩ul4R↓↓↓↓α↓↓↓αl*6>JMZ1.2t∩fεv⎇B2:
L
}b2u:⊃*b<"
elhQ↓↓↓α↓↓↓↓∧j⊗6>∃Jn1.∧~↑∩v⎇BB∞↑%zbB∞dq*b2u:⊃l4R↓↓↓↓α↓↓↓αl*6>JMZ1.B≤∩fv}Eα∞
f⎇BB∞2rRb2:∃Il4)α↓↓↓↓α↓↓α6,j>Jf\a.B∞∃Jεv}Eα∞
f
zbB∞dq*b2t∩f¬lhQ↓↓↓α↓↓↓↓∧j⊗6>∃Jn1.<"
&v⎇B↑∩
Mzb↑∩∃I*b
L∩%l4R↓↓↓↓α↓↓↓αl*6>JMZ1.
l
bv⎇C α2NBαb
f∀I%5EXh)↓↓α↓↓↓↓ααJ⊗2,
N∃"≤A%l4R↓↓↓↓α↓↓↓α∀*RVJrAEM.Eα∞29]B2:
L .bB≥:⊃%lhQ↓↓↓α↓↓↓↓∧*:⊂4R↓↓↓↓αα⊗2N(h)↓↓α↓↓↓↓αα
⊗≡Lq↓↓β≡{77↔w!β'→ε{3⊃βF ;⊃β/K∃β≠␈∪7πQXh)↓↓α↓↓↓↓αα2}2|~εR&|q"B&≥"VJ∃KX4)↓α↓↓↓↓α↓α6⊗lzJfnbZ
f
Mj}b
L∩&}
,2mJuXh)↓↓α↓↓↓↓αα6⊗6⎇∩fn1\b:
fmzb2:∃J}
V5Ybu6∃*~m↑jYEl4R↓↓↓↓α↓↓↓αl*6>JMZ1.B≤b:v}Eα∞2:|∩V~m5i6
V5YVu- X4)↓α↓↓↓↓α↓α6⊗lzJfnbZ↑∩
Mj}b↑$∩f⎇M2*b
f∀Il4)α↓↓↓↓α↓↓α6,j>Jf\a.2:<"v}bdr↑∩⎇EB2:
JZb↑∩∃I5E%-B↑∩
KX4)↓α↓↓↓↓α↓α6⊗lzJfnbZ2:
L
v}bdr
fε⎇B2:↑"Rb↑∩∃Il4)α↓↓↓↓α↓↓α6,j>Jf\a.B∞<"v}b∧~↑∩}Eα∞29UB2:↑#X4)↓α↓↓↓↓α↓α6⊗lzJfnbZB∞
Mj}bB≤∩f}b∧~29*Db:
eXh)↓↓α↓↓↓↓αα6⊗6⎇∩fn1]α∞
f
j}bB≤∩fε}Eα∞29UB2:
L l4)α↓↓↓↓α↓↓α6,j>Jf\a.↑∩∀Jv}b<"
&}E:∩
eUB
f
KX4)↓α↓↓↓↓α↓α6⊗lzJfnbZ
6εEj⎇!E∧bN!αD∩f
%JiEl4R↓↓↓↓α↓↓↓αL1αb
L∩$qA↓yαb
L∩%yM2⎇αbdr
dqα⎇αb∧~28qα⎇α
,2mBuc↓αR",p4)↓α↓↓↓↓α↓↓↓↓∧∩⊗≡&ph)↓↓α↓↓↓↓α↓↓↓α∀*2⊗ε≤)"∞!KX4)↓α↓↓↓↓α↓↓↓↓¬∩⊗RV∀q!A%Xh)↓↓α↓↓↓↓α↓↓↓α,r⊃l4R↓↓↓↓α↓↓↓α∀*2⊗ε≤)"∞!KX4)↓α↓↓↓↓α↓αJ⊗%*J9! →.bB≤b9.bdr
f¬]BB∞↑"Il4)α↓↓↓↓α↓↓α⊗t!l4)α↓↓↓↓∧*:⊃lhQ↓↓α,r⊃l4P3';&+K;πbα&:R,:⊗Iα¬∩>∞⊗%*J∃α<*RB~bBNRJLr≥α~Lb:ε5ZαJ⊗~-∩⊗*∞*α&:R,:⊗Iα∧J∞RV∀)%l4R↓β∂?nk↔;QαβK↔π"βS#∃πβ'∂S/∪∃β'rα~&2t
5β'w#=βπ⊗+¬β?2β∂?K*β←#?≡)β≠'↔≠P4λHK←?K"β'Mα∧J∞RV∀)9αB4b∩&5D2&2: i%β←␈∪∪Mβ∂∪∃β;.+∪↔⊃ph($&⊗+SWKw→βC'∨#WK∃π≠'k∃ε{9βO.≠∂↔O~a↓Aβ}qβ≠πNcWK∃Xh)↓↓∧∩⊗≡&ph)↓↓∧J:R⊗<*Iα∞⎇*:Q2∃∩∞"ε∩b⊗>→eα&∞2|→mα
|z2⊗εrα~2ε;X4)↓αα&:R,:⊗IαEα∞29eBB∞↑"bbB∞∃I2bB≤∩f¬2Db:↑⊃eB2:
Jbb2:∃J¬2b<"
e2E:∩
%eB
f
KX4)↓αα&:R,:⊗IαJb12∞CX4)↓αα&:R,:⊗Iα
∩Jεe∧∩V~mβQ≥E]=il4(hQ↓↓α≤B}≡⊗$~"ε9Xh)↓↓¬αJN~La"~&drε5%Xh)↓↓∧*>~}%∩V∃lhQ↓↓α⎇α⊗9"≤A2∩⊗5αJM1; A1EJaA2∞⎇*:Q2∃∩∞"ε∩b⊗>→KX4)↓αα&→,*>→α$B⊗9αdz>.VαB∞!24J2BJ~b~2ε:Il4)α↓α&→∧22ε≥↓yα⊗>2αR"⊗ph)↓↓α↓↓↓α∀*≡&8hQ↓↓↓α↓↓αJ,b⊗εN*B∞!%Xh)↓↓α↓↓↓α∀*RVJrAA%lhQ↓↓↓α↓↓α⊗t 4)↓αα⊗"N(h)↓↓α↓↓α
,:&84R↓↓↓↓αα&:R,:⊗IαZb.-lhQ↓↓↓α↓αεJ∃J&9"≤A2
V5YBu1 ↓%l4R↓↓↓↓αα&→α∃*~mBki5D}∃*~mBki5H}∃*~mBkiEIa¬""⊗8hQ↓↓↓α↓↓↓↓∧∩⊗≡&ph)↓↓α↓↓↓↓ααεJJLJ9"∞Bb
V~[ Bu1;⊃AA5 ↓%l4R↓↓↓↓α↓↓↓α\Z⎇≥Iβ↓l4)α↓↓↓↓α↓↓↓↓αβ∂?7n+;Qβ6{Iα6M!βCO/+∪=β∨#π;≠␈∪⊃β≠␈∪7πQbβ←#'≡Aβ#π~β;=βε{';S/∪Ml4R↓↓↓↓α↓↓↓αL1α
V5YBtm ⊃aαRD*9α~⎇⊃α.⎇ A1E]c Y1E*aEA1Jaa1]∧"=α&2α
V~\ZtmA¬""⊗9∧Z.}
,2n.uXh)↓↓α↓↓↓↓αα2}2|~εR&|q"B&≥"VJ∃KX4)↓α↓↓↓↓α↓α6⊗lzJfnbZ
f
Mj}b
L∩&}
,2mFuXh(%αl*6>JMZ1.2t∩fv}Db:
f|J→α
,2mBuk Iaα$B⊗9α∃*~mJjα⊗2N*α
V~[2u6
,2mVu[ l4(Jα6⊗6⎇∩fn1]α∞2:mzbB∞dr}&→∧∩V~m¬iuEIBαR"⊗rα
V~["u⊗
,2mNu∧*2N∃∧∩V~m%i6
V5YNu- X4(%∧j⊗6>∃Jn1.dr↑∩v⎇B2:↑%z&→α∃*~mBkiEIa¬""⊗9∧∩V~m≥iα⊗2≤)α
V5YJulhQ↓↓↓α↓↓↓↓∧j⊗6>∃Jn1.<"
fv⎇B↑∩
MyMY⊗D∩f
%Xh)↓↓α↓↓↓↓αα6⊗6⎇∩fn1\b:
f
j}b2t∩fε}Db:↑⊃UB↑∩
KX4)↓α↓↓↓↓α↓α6⊗lzJfnbZB∞↑%j}bB≥:∩}b∧~29*Db:↑⊃Xh)↓↓α↓↓↓↓αα6⊗6⎇∩fn1]α∞
fmzbB∞∃J}bB≤b9*bdr
elhQ↓↓↓α↓↓↓↓∧j⊗6>∃Jn1.∧~
fεmzbB∞∃Jε}b∧~29*Db:
f X4)↓α↓↓↓↓α↓α6⊗lzJfnbZ↑∩
Mj}b↑$∩&}b<"
e*D∩f
%Xh)↓↓α↓↓↓↓αα6⊗6⎇∩fn1\∩6εbmy!Eαe~!αb∃J
%%k l4)α↓↓↓↓α↓↓α6,j>Jf\a.
B$
v⎇ →.bB≤b9.1Xh)↓↓α↓↓↓↓αα6ε.$
"BL~RVJ*Il4)α↓↓↓↓α↓↓αBL~2>∞zB.-αd
:⊃↓;9]]];9%↓5α9IAAXh)↓↓α↓↓↓↓αα&→α∧J∞2>≠aAαRD*9α
,:&9α-~⊗R%D~!1EKYαB&≤b>∞}∧J∞2>~Y≥IAβYα⊗:#X4)↓α↓↓↓↓α↓α~>∩α&⎇E¬~R⊗Aβ αV:$J1αBL~2>
∧"=α↑⎇∩∩&9D~!%lhQ↓↓↓α↓↓↓↓∧J→α
,2mBujiD}
,2mBuk Iaα$B⊗84R↓↓↓↓α↓↓↓↓α↓αεJ∃J&9"≤A26⊗lzJfnbYEM.Eα∞29]B2:
L
u2b∧~↑⊃%∧*2N∀hQ↓↓↓α↓↓↓↓∧J→α
,2mBujiIαRD*84)α↓↓↓↓α↓↓↓↓αα
⊗≡Lq↓β∂|k7↔;"↓β'→ε β∂?oβK↔O≡+⊃βCN≠SWK+X4)↓α↓↓↓↓α↓↓↓↓∧J:R⊗<*IαB∀*Y2
M"]2
M"9l4PI↓↓↓∧∩&R:{ mαB∀*Z⎇AXh(%↓α↓α2}bYEM.Eα∞29]B2:
L l4(J↓↓↓α4zIα&|aαNR-↓↓Eα,rR&1∧a.bB≥:⊃5E∧"<4(J↓↓↓↓α↓α
⊗<J84(J↓↓↓↓α↓α&→αB
&Ruz
&RLSH -1)=0 THEN
BEGIN BITW←WORDIN(CH); BITN←'400000000000; END;
IF (BITW LAND BITN)≠0 THEN PREV←WORDIN(CH);
MEMORY[I]←PREV;
END;
END;
RELEASE(CH);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END
ELSE
BEGIN comment if old hand eye format;
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BUF[2];
MEMORY[L+LNBY]←XLNBY←BUF[8]-BUF[7]+1;
MEMORY[L+PCLN]←XPCLN←BUF[6]-BUF[5]+1;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←(XLNBY+XWDBY-1)%XWDBY;
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+BMAX]←(1 LSH XBYBI)-1;
MEMORY[L+BPTAB]←13+XPCLN+L;
MAKTAB(PICTURE);
IF XBYBI≤0 ∨ XBYBI>36 ∨ XLNBY≤0 ∨ XPCLN≤0 ∨ BUF[0]<0 THEN
BEGIN
RELEASE(CH);
RETURN(0);
END;
ARRYIN(CH,MEMORY[L+13+XPCLN+XLNBYA],XPCWD);
RELEASE(CH);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
END;
END;
internal INTEGER PROCEDURE PIXDIM(INTEGER HEIGHT,WIDTH,BITS);
comment returns the size of the array needed to hold a hypothetical
picture HEIGHT scanlines by WIDTH pixels per scanline
by BITS bits per pixel.;
BEGIN
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER L;
XBYBI←BITS;
XLNBY←WIDTH;
XPCLN←HEIGHT;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
internal INTEGER PROCEDURE MAKPIX(INTEGER HEIGHT,WIDTH,BITS; REFERENCE INTEGER PICTURE);
comment actually creates an empty picture HEIGHT by WIDTH by BITS in
the area of core beginning with PICTURE. Returns its size.;
BEGIN
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L;
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BITS;
MEMORY[L+LNBY]←XLNBY←WIDTH;
MEMORY[L+PCLN]←XPCLN←HEIGHT;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←(XLNBY+XWDBY-1)%XWDBY;
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+BMAX]←(1 LSH XBYBI)-1;
MEMORY[L+BPTAB]←13+XPCLN+L;
MAKTAB(PICTURE);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
internal INTEGER PROCEDURE MAKDIM(INTEGER HEIGHT,WIDTH,BITS; REFERENCE INTEGER PICTURE);
comment creates an internal picture header for HEIGHT by WIDTH by BITS
in the first 11 words of PICTURE. does not touch line and
byte pointer areas;
BEGIN
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L;
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BITS;
MEMORY[L+LNBY]←XLNBY←WIDTH;
MEMORY[L+PCLN]←XPCLN←HEIGHT;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←(XLNBY+XWDBY-1)%XWDBY;
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+BMAX]←(1 LSH XBYBI)-1;
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
internal INTEGER PROCEDURE PUTPFL(REFERENCE INTEGER PICTURE; STRING FILNAM;
INTEGER MODE(1));
comment write out the picture in the core area starting with
PICTURE, creating a file called FILNAM. Returns
the size of the original file on success, else 0.
If MODE is 2, picture will be written out in
data-compressed form;
BEGIN
INTEGER COUNT,BRCHAR,EOF,PICLOC; BOOLEAN FLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L,CH;
INTEGER ARRAY BUF[0:'177];
CH←GETCHAN;
PRSFIL(FILNAM);
EOF←TRUE;
OPEN(CH,DEVPRS,'10,0,19,COUNT,BRCHAR,EOF);
IF ¬EOF THEN ENTER(CH,FILPRS,FLAG);
IF FLAG ∨ EOF THEN
BEGIN
RELEASE(CH);
RETURN(0);
END
ELSE
BEGIN
L←LOCATION(PICTURE);
BUF[0]←-MODE;
BUF[1]←XBYBI←MEMORY[L+BYBI];
BUF[2]←XLNWD←MEMORY[L+LNWD];
BUF[3]←1; BUF[4]←XPCLN←MEMORY[L+PCLN];
BUF[5]←1; BUF[6]←XLNBY←MEMORY[L+LNBY];
BUF[7]←((-(XPCWD←MEMORY[L+PCWD])) LSH 18) LOR '200;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
ARRYOUT(CH,BUF[0],'200);
IF MODE=1 THEN ARRYOUT(CH,MEMORY[L+13+XPCLN+XLNBYA],XPCWD) ELSE
IF MODE=2 THEN
BEGIN comment Data compressed output;
INTEGER BITN,PREV,BUFP,BITW;
BITN←'400000000000; PREV←0; BUFP←0; BITW←0;
L←L+13+XPCLN+XLNBYA;
FOR I←L STEP 1 UNTIL L+XPCWD-1 DO
BEGIN
IF MEMORY[I]≠PREV THEN
BEGIN
BUF[BUFP←BUFP+1]←(PREV←MEMORY[I]);
BITW←BITW LOR BITN;
END;
IF (BITN←BITN LSH -1)=0 THEN
BEGIN
BUF[0]←BITW; ARRYOUT(CH,BUF[0],BUFP+1);
BITN←'400000000000; BUFP←0; BITW←0;
END;
END;
IF BITN≠'400000000000 THEN BEGIN BUF[0]←BITW; ARRYOUT(CH,BUF[0],BUFP+1); END;
END;
RELEASE(CH);
RETURN(13+XPCLN+XLNBYA+XPCWD);
END;
END;
internal INTEGER PROCEDURE diminterest(REFERENCE INTEGER PICTURE; INTEGER IW);
BEGIN
INTEGER HIG,WID,BITS;
HIG←MEMORY[LOCATION(PICTURE)+PCLN];
WID←MEMORY[LOCATION(PICTURE)+LNBY];
BITS←MEMORY[LOCATION(PICTURE)+BYBI];
RETURN(PIXDIM((HIG-1)%IW,(WID-1)%IW,10));
END;
internal PROCEDURE INTEREST(REFERENCE INTEGER PICTURE; INTEGER IW;
REFERENCE INTEGER RESULT);
BEGIN
INTEGER HIG,WID,BITS,IAV,I,J,IWW,BYMAX;
EXTERNAL PROCEDURE GETPAR(REFERENCE INTEGER ARY, PICT);
HIG←MEMORY[LOCATION(PICTURE)+PCLN];
WID←MEMORY[LOCATION(PICTURE)+LNBY];
BITS←MEMORY[LOCATION(PICTURE)+BYBI];
BEGIN
INTEGER ARRAY INTER[-2:(HIG-1)%IW-1,0:(WID-1)%IW-1];
IAV←INTOP(PICTURE,IW,INTER[0,0]);
IWW←IW*IW;
BYMAX←2↑BITS-1;
FOR I←(HIG-1)%IW-1 STEP -1 UNTIL 0 DO
FOR J←(WID-1)%IW-1 STEP -1 UNTIL 0 DO
INTER[I,J]←8*SQRT(INTER[I,J]/IWW) MIN BYMAX;
MAKPIX((HIG-1)%IW,(WID-1)%IW,BITS,RESULT);
GETPAR(INTER[0,0],RESULT);
END;
END;
INTERNAL PROCEDURE ENHANCE(REFERENCE INTEGER PIC);
BEGIN
INTEGER INTEG,I,TOT,BITS,SAMPS;
BITS←MEMORY[LOCATION(PIC)+BYBI];
SAMPS←2↑BITS;
BEGIN
INTEGER ARRAY GREYS[0:SAMPS-1];
HISTOG(PIC,GREYS[0]);
TOT←0;
FOR I←0 STEP 1 UNTIL SAMPS-1 DO TOT←TOT+GREYS[I];
INTEG←0;
FOR I←0 STEP 1 UNTIL SAMPS-1 DO
BEGIN
INTEG←INTEG+GREYS[I];
GREYS[I]←(SAMPS-1)*INTEG/TOT;
END;
PERBIT(PIC,GREYS[0]);
END;
END;
INTERNAL PROCEDURE SYNCHRONIZE(REFERENCE INTEGER PIC);
BEGIN
INTEGER I,J,K,WINPOS,HIG;
REAL WINVAL,TRIALVAL;
HIG←MEMORY[LOCATION(PIC)+PCLN];
BEGIN
INTEGER ARRAY ROWSM[0:HIG-1];
DEFINE DK=".6";
ROWSUD(PIC,ROWSM[0]);
WINPOS←HIG-1;
WINVAL←ROWSM[HIG-1];
FOR I←0 STEP 1 UNTIL HIG-1 DO WINVAL←WINVAL*DK + ROWSM[I]*(1-DK);
TRIALVAL←WINVAL;
FOR J←0 STEP 1 UNTIL HIG-1 DO
BEGIN
TRIALVAL←TRIALVAL*DK + ROWSM[J]*(1-DK);
IF TRIALVAL≤WINVAL THEN
BEGIN
WINVAL←TRIALVAL;
WINPOS←J;
END;
END;
IF WINPOS<HIG-1 THEN
BEGIN
INTEGER BODY,BODYSIZ;
INTEGER ARRAY COPY[0:BODYSIZ←MEMORY[LOCATION(PIC)+PCWD]];
BODY←MEMORY[LOCATION(PIC)+LINTAB];
WINPOS←(WINPOS+1)*MEMORY[LOCATION(PIC)+LNWD];
ARRBLT(COPY[0],MEMORY[BODY+WINPOS],BODYSIZ-WINPOS);
ARRBLT(COPY[BODYSIZ-WINPOS],MEMORY[BODY],WINPOS);
ARRBLT(MEMORY[BODY],COPY[0],BODYSIZ);
END;
END;
END;
Comment All gone now...just like the digitizer;
IFC FALSE THENC
INTERNAL INTEGER PROCEDURE CAMPIX(INTEGER CAMRA,YEDGE,XEDGE;
REFERENCE INTEGER PICTURE;
INTEGER SUMS(1),BCLIP(7),TCLIP(0),NTRY(10));
comment read a picture from camera CAMRA of size defined by array PICTURE
the area of core beginning with PICTURE. Upper left hand
corner is at PICX,PICY. SUMS and CLPINC are averaging params.;
BEGIN
EXTERNAL INTEGER PROCEDURE TVSNAP(INTEGER CAM,YEDG,XEDG;
REFERENCE INTEGER PIC;
INTEGER BCLIP,TCLIP,NTRY);
EXTERNAL INTEGER PROCEDURE TVRAW(INTEGER CAM,YEDG,XEDG;
REFERENCE INTEGER PIC;
INTEGER BCLIP,TCLIP,NTRY);
EXTERNAL PROCEDURE WIPE(REFERENCE INTEGER PICTURE; INTEGER VALUE);
EXTERNAL PROCEDURE TVBTMX(REFERENCE INTEGER PIC4,PICN,XFRM; INTEGER TOPV(7));
EXTERNAL PROCEDURE PICADD(REFERENCE INTEGER PICTURE,PICSUM);
EXTERNAL PROCEDURE SHRINK(REFERENCE INTEGER PIC1,PIC2);
EXTERNAL PROCEDURE PICSH(REFERENCE INTEGER PIC1,PIC2; INTEGER DIV);
INTEGER XPCLN,XLNBY,XBYBI;
INTEGER L,CAM,DW,ERS,I,J,K,NDEL;
PRELOAD_WITH '12,'13,'11,'10,'15,'14,'16,'17,'5,'4,'6,'7,'2,'3,'1,'0;
OWN INTEGER ARRAY GREY[0:15];
IF CAMRA>'40 THEN CAMRA←CAMRA LAND '67;
IF CAMRA='42∨CAMRA='41 THEN CAM←CAMRA LAND 3 ELSE
BEGIN
INTEGER I,J;
I←'401400000000 LOR LOCATION(J);
J←IF CAMRA≥'40 THEN CAMRA LAND 7 ELSE 1 LSH (35-CAMRA);
START_CODE
MOVE 1,I;
CALLI 1,'400070; COMMENT VDSMAP;
JUMP 0,0;
END;
CAM←3;
END;
L←LOCATION(PICTURE);
XPCLN←MEMORY[L+PCLN];
XLNBY←MEMORY[L+LNBY];
XBYBI←MEMORY[L+BYBI];
NDEL←0; SUMS←SUMS MAX 1;
BEGIN
INTEGER ARRAY T1[0:IF XBYBI≠4 THEN PIXDIM(XPCLN,XLNBY,4) ELSE 0],
T[0:IF SUMS>1 THEN PIXDIM(XPCLN,XLNBY,12) ELSE 0];
IF XBYBI≠4 THEN MAKPIX(XPCLN,XLNBY,4,T1[0]);
IF SUMS>1 THEN
BEGIN
MAKPIX(XPCLN,XLNBY,12,T[0]);
WIPE(T[0],0);
END;
ERS←0;
FOR K←1 STEP 1 UNTIL SUMS DO
BEGIN
IF XBYBI>4 THEN
BEGIN
INTEGER CLPINC,TC,BC,CLPSTP;
INTEGER MXBY;
MXBY←2↑XBYBI-1;
CLPINC←(BCLIP-TCLIP+1)*15/MXBY;
CLPINC←((CLPINC MAX 1) MIN 7);
CLPSTP←CLPINC%2 MAX 1;
WIPE(PICTURE,-1);
TC←TCLIP;
DO
BEGIN
INTEGER ARRAY XFRM[0:15];
REAL TM,BM;
BC←TC+CLPINC-1;
TM←(BCLIP+1-TC)*MXBY/(BCLIP-TCLIP+1);
BM←(BCLIP-BC)*MXBY/(BCLIP-TCLIP+1);
FOR I←0 STEP 1 UNTIL 15 DO
XFRM[I]←
((2*GREY[I]*(TM-BM)+TM+29*BM)/30 MAX 0) MIN MXBY;
DW←TVRAW(CAM,YEDGE,XEDGE,T1[0],BC,TC,NDEL←NDEL+NTRY);
IF DW≥0 THEN
BEGIN
TVBTMX(T1[0],PICTURE,XFRM[0],7);
TC←TC+CLPSTP;
END;
END
UNTIL BC≥BCLIP∨DW<0;
ERS←ERS+DW;
END
ELSE
IF XBYBI=4 THEN
DW←TVSNAP(CAM,YEDGE,XEDGE,PICTURE,BCLIP,TCLIP,NDEL←NDEL+NTRY)
ELSE
IF XBYBI<4 THEN
DW←TVSNAP(CAM,YEDGE,XEDGE,T1[0],BCLIP,TCLIP,NDEL←NDEL+NTRY);
IF DW≥0 THEN
BEGIN
IF SUMS>1 THEN PICADD(PICTURE,T[0]);
ERS←ERS+DW;
END
ELSE
BEGIN
K←SUMS;
ERS←-1;
END;
END;
IF ERS≥0 THEN
IF SUMS>1 THEN PICSH(T[0],PICTURE,SUMS) ELSE
IF XBYBI<4 THEN SHRINK(T1[0],PICTURE);
END;
RETURN(ERS);
END;
INTERNAL INTEGER PROCEDURE CLPADJ(INTEGER CAMRA;
REFERENCE INTEGER BCLIP,TCLIP;
REAL LIMB(.01),LIMT(.01));
BEGIN
INTEGER ARRAY T[0:PIXDIM(200,200,4)];
INTEGER NRT;
MAKPIX(200,200,4,T[0]);
NRT←CAMPIX(CAMRA,20,20,T[0],1,7,0,10);
IF NRT≥0 THEN
BEGIN
INTEGER ARRAY A[0:15],TT,TB[0:7]; INTEGER I,S,P;
HISTOG(T[0],A[0]);
S←0; FOR I←0 STEP 1 UNTIL 7 DO S←S+(TB[I]←TT[I]←A[15-2*I]+A[14-2*I]);
LIMB←LIMB*S; LIMT←LIMT*S;
FOR I←1 STEP 1 UNTIL 7 DO TT[I]←TT[I]+TT[I-1];
FOR I←6 STEP -1 UNTIL 0 DO TB[I]←TB[I]+TB[I+1];
TCLIP←0; BCLIP←7;
FOR I←0 STEP 1 UNTIL 7 DO IF ABS(TT[I]-LIMT)<ABS(TT[TCLIP]-LIMT) THEN TCLIP←I;
FOR I←7 STEP -1 UNTIL TCLIP DO IF ABS(TB[I]-LIMB)<ABS(TB[BCLIP]-LIMB)
THEN BCLIP←I;
END;
RETURN(NRT);
END;
Sorry about that Hans...
ENDC
end